home *** CD-ROM | disk | FTP | other *** search
/ Merciful 5 / Merciful - Disc 5.iso / software / p / pcqpascalv1.2d.lha / Examples2 / DxBoot / DxBoot.p < prev   
Text File  |  1997-05-06  |  11KB  |  476 lines
  1. Program DxBoot;
  2.  
  3. {$I "include:exec/IO.i"          }    { * Version 1.2, 22.12.1992 * }
  4. {$I "include:exec/Memory.i"      }    { * (C) by "Diesel" Bernd   * }
  5. {$I "include:exec/Devices.i"     }    { * Künnen, D-4477 Twist    * }
  6. {$I "include:exec/ExecBase.i"    }
  7. {$I "include:Utils/IOUtils.i"    }
  8. {$I "include:libraries/dos.i"    }
  9. {$I "include:utils/stringlib.i"  }
  10. {$I "include:utils/parameters.i" }
  11.  
  12. CONST
  13.     CMD_MOTOR   = 9;        { ist nicht in execIO.i def., }
  14.  
  15.     CMD__Null   =  0;
  16.     CMD__Kill   =  1;
  17.     CMD__Read   =  2;
  18.     CMD__Write  =  3;
  19.     CMD__Chk    =  4;
  20.     CMD__inst   =  5;
  21.     CMD__Cmp    =  6;
  22.     CMD__Type   =  7;    { * Nummern der einzelnen * }
  23.     CMD__Help   =  8;    { * Dxboot-Kommandos      * }
  24.     CMD__Test   =  9;
  25.  
  26.     on          = 1;
  27.     off        = 0;
  28.     dev         : String = "trackdisk.device";
  29.  
  30.     ErrorTD_IO : String = " Error on trackdisk-IO\n";
  31.     DosErr_Rf  : String = " Error reading file\n";
  32.     DosErr_Wf  : String = " Error writing file\n";
  33.  
  34.  
  35.  
  36. Type
  37.     BB    = Array[0..1023] Of Byte;       { * 1 Bootblock = 1024 Bytes * }
  38.     BBPtr = ^BB;
  39.  
  40. VAR
  41.     comm,
  42.     i        : Short;
  43.     ok,
  44.     dfx      : Integer;
  45.     ArgStr   : String;
  46.     Handle   : FileHandle;
  47.     BB1,
  48.     BB2      : BBPtr;
  49.  
  50.  
  51.  
  52.  
  53. { --- Zum sauberen Verlassen des Programms, egal, von wo ! --- }
  54.  
  55. Procedure Cleanexit(why : String; RT : Integer);
  56. Begin
  57.     IF handle <>NIL then DOSClose(handle);  { --- File schließen --- }
  58.     IF BB1    <>NIL then FreeMem(BB1,1024); { --- ChipMem freigeben --- }
  59.  
  60.     IF why<>NIL then begin            { --- Wenn Fehler: --- }
  61.       writeln(why);
  62.       If RT=5 then write("\nUsage : DxBoot cmd unit[0..3] <filename>\n",
  63.                   "Type    DxBoot ? for help\n\n");
  64.  
  65.       Delay(100);                { --- 2 s warten --- }
  66.     end;
  67.     Exit(RT);
  68. End;
  69.  
  70.  
  71.  
  72. { --- HexDump des BB`s ausgeben --- }
  73.  
  74. Procedure DumpBB;
  75.  
  76. Const
  77.     hex  : ARRAY[0..15] OF Char =  ('0123456789ABCDEF');
  78.  
  79. Var
  80.     BW  : Byte;
  81.     k,j : Short;
  82.     Buf : String;    
  83.  
  84. Begin
  85.  
  86.       k:=0;                { --- Setup --- }
  87.       Buf:=AllocString(70);
  88.  
  89.       Buf[48]:=' ';            { --- Leerzeichen --- }
  90.       Buf[49]:=' ';
  91.       Buf[66]:=chr(10);            { --- Return & linefeed --- }
  92.       Buf[67]:=chr(0);            { --- Abschlußbyte/Str.=0 --- }
  93.  
  94.       For i:=1 to 64 Do BEGIN        { --- 64 Zeile zu 16 Bytes --- }
  95.     For j:=0 to 15 Do Begin
  96.       BW:=BB1^[k];
  97.       Buf[j*3]:=' ';        { --- Leerzeichen --- }
  98.       Buf[j*3+1]:=hex[BW DIV 16];    { --- Byte-hälfte high ---}
  99.       Buf[j*3+2]:=hex[BW MOD 16];    { --- Byte-hälfte low  --- }
  100.  
  101.       IF ((BW > 31) AND (BW < 123)) then
  102.         Buf[50+j]:=chr(BW)
  103.       ELSE                { --- Ggf. (A..z) --- }
  104.         Buf[50+j]:='.';        { --- sonst   .   --- }
  105.  
  106.           inc(k);            { --- k  um 1 erhöhen --- }
  107.     End;
  108.       write(Buf);            { --- Zeile ausgeben --- }
  109.       End;
  110. end;
  111.  
  112.  
  113.  
  114. Procedure InstantBB(bbm : BBPtr; v : Short);
  115.                     { --- Trägt in bbm^ einen BB ein --- }
  116.                     { --- je nach SYSversion 1.3/2.0 --- }
  117. Const
  118.     BB13 : ARRAY[0..48] OF Byte = ( $44, $4F, $53, $00, $C0, $20, $0F, $19,
  119.                     $00, $00, $03, $70, $43, $FA, $00, $18,
  120.                     $4E, $AE, $FF, $A0, $4A, $80, $67, $0A,
  121.                     $20, $40, $20, $68, $00, $16, $70, $00,
  122.                     $4E, $75, $70, $FF, $60, $FA, $64, $6F,
  123.                     $73, $2E, $6C, $69, $62, $72, $61, $72,
  124.                     $79, );
  125.  
  126.     BB20 : ARRAY[0..92] OF Byte = ( $44, $4F, $53, $00, $E3, $3D, $0E, $73,
  127.                     $00, $00, $03, $70, $43, $FA, $00, $3E,
  128.                     $70, $25, $4E, $AE, $FD, $D8, $4A, $80,
  129.                     $67, $0C, $22, $40, $08, $E9, $00, $06,
  130.                     $00, $22, $4E, $AE, $FE, $62, $43, $FA,
  131.                     $00, $18, $4E, $AE, $FF, $A0, $4A, $80,
  132.                     $67, $0A, $20, $40, $20, $68, $00, $16,
  133.                     $70, $00, $4E, $75, $70, $FF, $4E, $75,
  134.                     $64, $6F, $73, $2E, $6C, $69, $62, $72,
  135.                     $61, $72, $79, $00, $65, $78, $70, $61,
  136.                     $6E, $73, $69, $6F, $6E, $2E, $6C, $69,
  137.                     $62, $72, $61, $72, $79  );
  138.  
  139.     BBNB : ARRAY[0..2] OF Byte = ( $44, $4f, $53 );
  140.  
  141. Var
  142.     MyExecBasePtr :    ExecBasePtr;
  143.     j   : short;
  144.  
  145. Begin
  146.     If v = 0 then Begin
  147.       MyExecBasePtr:=Address(4);
  148.       If MyExecBasePtr^.SoftVer < 36    { --- Kick 1.3 ? --- }
  149.       then  v := 13
  150.       else  v := 20;
  151.     End;
  152.  
  153.     If v = 13 then
  154.       for j:=0 to 48 do  bbm^[j]:=BB13[j];    { --- 1.3-BB kopieren --- }
  155.  
  156.     If v = 20 then
  157.       for j:=0 to 92 do  bbm^[j]:=BB20[j];    { --- 2.0-BB kopieren --- }
  158.  
  159.     If v = -1 then
  160.       for j:=0 to  2 do  bbm^[j]:=BBNB[j];    { --- Not booting Disk --- }
  161.  
  162.  
  163.     for j:=j to 1023 do  bbm^[j]:=0;    { --- mit 0 auffüllen --- }
  164.  
  165. End;
  166.  
  167.  
  168.  
  169.     { ------- Bootblock-Ein/Ausgabe ------- }
  170.  
  171. Function RWBB(unit: Integer; cmd: Short; mem: Address):Boolean;
  172.  
  173.  
  174. PROCEDURE Motor(iostdr:IOStdReqPtr; switch:Integer);
  175. Var                            { dfx-Motor an/aus }
  176.     okm : Integer;
  177. BEGIN
  178.   iostdr^.io_Command:=CMD_MOTOR;            { Motor schalten   }
  179.   iostdr^.io_Length:=switch;                { on/off übergeben }
  180.   okm:=DoIO(iostdr);                    { GO ! }
  181. END;    { Motor }
  182.  
  183.  
  184.  
  185. Var
  186.     myReq    : IOStdReqPtr;            { zur Kommun. mit dem }
  187.     myPort   : MsgPortPtr;            { trackdisk.device    }
  188.  
  189.  
  190. Begin
  191.     myPort:=CreatePort(NIL,0);        { Nachrichtenport des Laufwerks }
  192.     myReq:=CreateStdIO(myPort);        { Kommunikationsport einrichten }
  193.  
  194.     ok:=OpenDevice( dev, unit, myReq, 0 );    { TrackDisk öffnen }
  195.  
  196.     IF ok=0 THEN BEGIN
  197.  
  198.       With myReq^ do begin
  199.         io_Data    := mem;            { Speicherbereich }
  200.         io_Offset  := 0;            { Offset = Block 0 }
  201.         io_Length  := 1024;            { 1024 bytes }
  202.         io_Command := CMD_CLEAR;        { zuerst Trackbuffer löschen }
  203.       end;
  204.  
  205.       ok:=DoIO(myReq);
  206.       If ok=0 then begin            { wenn gelöscht, dann }
  207.  
  208.         myReq^.io_command := cmd;        { BB schreiben/lesen  }
  209.         ok:=DoIO(myReq);
  210.  
  211.         If (ok=0) AND (cmd    =CMD__Write) then begin
  212.           myReq^.io_Command := CMD_UPDATE;
  213.           ok:=DoIO(myReq);            { zum Schreiben "updaten" }
  214.         end;                { d.h. Trackbuffer -> Disk }
  215.  
  216.       end;
  217.  
  218.       If comm = CMD__Test Then        { Bootblock ausführen : }
  219.       Begin
  220. {$A
  221. _jumpIntoBBcode:
  222.  
  223.     move.l     4,a6        ; execbase in a6
  224.     move.l    -4(a5),a1    ; IOsStdReqPtr in a1
  225.     move.l     8(a5),a2    ; ^BB in Mem
  226.  
  227.     jsr    12(a2)        ; 'starte' BB
  228.  
  229. }
  230.  
  231.       End;
  232.  
  233.  
  234.       Motor(myReq,off);            { Motor aus & fertig }
  235.  
  236.       CloseDevice(myReq);            { Device schließen   }
  237.       DeleteStdIO(myReq);            { IOReq entfernen    }
  238.       DeletePort(myPort);            { MsgPort entfernen  }
  239.  
  240.       If ok=0 then RWBB:=TRUE else RWBB:=False;
  241.  
  242.     End Else RWBB:=FALSE;
  243.  
  244. End;
  245.  
  246.  
  247. { --- File-Ein/Ausgabe --- }
  248.  
  249. Function FileIO(cmd: Short; hdl: FileHandle; mem: Address): Boolean;
  250. Begin
  251.     CASE cmd of
  252.     Cmd__Read  :    ok:=DOSRead(hdl,mem,1024);    { BB aus Datei }
  253.     Cmd__Write :    ok:=DOSWrite(hdl,mem,1024);    { BB sichern   }
  254.     END;
  255.  
  256.     IF ok<>1024            { Bei Fehler Flase zurück }
  257.     then FileIO:=False
  258.     else FileIO:=True;
  259. End;
  260.  
  261.  
  262. { --- File je nach Bedarf öffnen, zur Ein/Ausgabe --- }
  263.  
  264. Procedure OpenFile(Mode: Integer);
  265. begin
  266.     GetParam(3,ArgStr);
  267.     If strlen(ArgStr)=0 then Cleanexit(" No filename",5);
  268.  
  269.     handle:=DosOpen(ArgStr, Mode);
  270.     If handle=NIL then CleanExit(" Could not open IO-File\n",10);
  271. end;
  272.  
  273.  
  274. { ------ Compare Bootblocks - gibt False zurück, wenn different  ----- }
  275.  
  276. Function CMPBB( c1, c2 : BBPtr) : Boolean;
  277. Var
  278.     z : Short;
  279. Begin
  280.     For z:=0to 1023 do
  281.       If c1^[z] <> c2^[z]  then CMPBB := False;
  282.  
  283.     CMPBB := True;
  284. End;
  285.  
  286.  
  287.  
  288. { --------------------  MAIN  ----------------------- }
  289.  
  290.  
  291.  
  292. BEGIN
  293.   write(" DxBoot 1.2, (C)1992 by Diesel. \n It`s Freeware!\n\n");
  294.   ArgStr:=AllocString(100);
  295.  
  296.  
  297.   { --- Kommando holen --- }
  298.  
  299.   GetParam(1,ArgStr);
  300.   If strlen(ArgStr)=0 then CleanExit(" No Args",5);
  301.  
  302.  
  303.   { --- nach a..z konvertieren --- }
  304.  
  305.   for i:=0 to strlen(ArgStr)-1 do
  306.     ArgStr[i]:=tolower(ArgStr[i]);
  307.  
  308.  
  309.   { --- Check, ob zulässiges Kommando --- }
  310.  
  311.   comm:=Cmd__Null;
  312.  
  313.   If strcmp(ArgStr,"read")  =0    then comm:=Cmd__Read;
  314.   If strcmp(ArgStr,"write") =0    then comm:=Cmd__Write;
  315.   If strcmp(ArgStr,"chk")   =0    then comm:=Cmd__Chk;
  316.   If strcmp(ArgStr,"inst")  =0    then comm:=Cmd__inst;
  317.  
  318.   If strcmp(ArgStr,"cmp")   =0    then comm:=Cmd__Cmp;
  319.   If strcmp(ArgStr,"type")  =0    then comm:=Cmd__Type;
  320.   If strcmp(ArgStr,"kill")  =0    then comm:=Cmd__Kill;
  321.   If strcmp(ArgStr,"test")  =0    then comm:=Cmd__Test;
  322.   If strcmp(ArgStr,"?")     =0    then comm:=Cmd__Help;
  323.  
  324.   If comm=Cmd__Null then cleanexit(" Not valid command",5);
  325.  
  326.  
  327.   { --- unit holen / df0..df3 = 0..3 --- }
  328.  
  329.   If comm<>CMD__Help then begin
  330.     GetParam(2,ArgStr);
  331.     IF StrLen(ArgStr)=0 THEN CleanExit(" No Unit# [0..3]",5)
  332.     else begin
  333.       Case Byte(ArgStr^) of
  334.     48 : dfx := 0;
  335.     49 : dfx := 1;        { 1. byte auf '0' - '3' testen }
  336.     50 : dfx := 2;
  337.     51 : dfx := 3;
  338.       Else
  339.     CleanExit(" Not valid unit number !",5);
  340.       End;
  341.     end;
  342.   End;
  343.  
  344.  
  345.   { --- Ggf. File zum Schreiben/Lesen öffnen --- }
  346.  
  347.   Case comm of
  348.     Cmd__Write,
  349.     Cmd__Cmp    : OpenFile(Mode_OldFile);
  350.     Cmd__Read    : OpenFile(Mode_NewFile);
  351.   End;
  352.  
  353.  
  354.   { --- 1 K Chip-RAM reservieren : --- }
  355.  
  356.   BB1:=BBPtr(AllocMem(1024,Memf_Chip));
  357.   If BB1=NIL then CleanExit(" Low on Chipmem !\n",10);
  358.  
  359.  
  360.   { --- zus. 1 K RAM f. Vergleichs-BB o.ä. --- }
  361.  
  362.   New(BB2);
  363.  
  364.  
  365.   { --- Kommando ausführen : --- }
  366.  
  367.   Case comm of
  368.     CMD__Read :        { --- BB speichern --- }
  369.     begin
  370.     If not (RWBB(dfx, CMD__Read, BB1))        then Cleanexit(ErrorTD_IO,10);
  371.     If not (FileIO(CMD__Write, handle, BB1))  then CleanExit(DosErr_Wf, 10);
  372.     end;
  373.  
  374.     CMD__Write :    { --- install  BB from file --- }
  375.     begin
  376.     If not (FileIO(CMD__Read, handle, BB1))   then CleanExit(DosErr_Rf ,10);
  377.     If not (RWBB(dfx, CMD__Write, BB1))       then Cleanexit(ErrorTD_IO,10);
  378.     end;
  379.  
  380.     CMD__Chk :        { --- check if Std.-BB --- }
  381.     begin
  382.  
  383.     If not (RWBB(dfx, CMD__Read, BB1))        then Cleanexit(ErrorTD_IO,10);
  384.  
  385.     InstantBB( BB2, 13 );            { Std.1.3-BB ? }
  386.     If ( CMPBB( BB1, BB2 ) ) then
  387.     Begin
  388.       write(" BB ok ( 1.3-BB)\n");
  389.       CleanExit( NIL, 0 );
  390.     End;
  391.  
  392.     InstantBB( BB2, 20 );            { Std.2.0-BB ? }
  393.     If ( CMPBB( BB1, BB2 ) ) then
  394.     begin
  395.       write(" BB ok ( 2.0-BB)\n");
  396.       CleanExit( NIL, 0 );
  397.     End;
  398.  
  399.     InstantBB( BB2, -1 );            { Not installed ? }
  400.     If ( CMPBB( BB1, BB2 ) ) then
  401.     begin
  402.       write(" Not installed disk\n");
  403.       CleanExit( NIL, 0 );
  404.     End;
  405.  
  406.     CleanExit(" No Std.-BB!!\n",10);
  407.     End;
  408.  
  409.     CMD__inst :        { --- install Std-BB, 1.3/2.0, je nach Kick --- }
  410.     begin
  411.     InstantBB( BB1, 0 );
  412.     If not (RWBB(dfx, CMD__Write, BB1))       then Cleanexit(ErrorTD_IO,10);
  413.     End;
  414.  
  415.     CMD__Cmp :        { --- BB vergleichen --- }
  416.     begin
  417.     If not (RWBB(dfx, CMD__Read, BB1))        then Cleanexit(ErrorTD_IO,10);
  418.     If not (FileIO(CMD__Read, handle, BB2))   then CleanExit(DosErr_Rf, 10);
  419.  
  420.  
  421.     If CmpBB( BB1, BB2 ) then
  422.     Begin
  423.       write(" BB equal 2 file\n\n");        { BB ok }
  424.       CleanExit(NIL,0);
  425.     End Else Begin
  426.       CleanExit(" BB -NOT- equal 2 file\n\n",10);    { Different ! }
  427.     End;
  428.  
  429.     End;
  430.  
  431.  
  432.     CMD__Type :        { --- HexDump(BB) --- }
  433.     begin
  434.     If not (RWBB(dfx, CMD__Read, BB1))        then Cleanexit(ErrorTD_IO,10);
  435.     DumpBB;
  436.     end;
  437.  
  438.     CMD__Kill :        { --- Install -> NDOS --- }
  439.     begin
  440.     For i:=0 to 1023 do
  441.       BB1^[i]:=0;
  442.  
  443.     If not (RWBB(dfx, CMD__Write, BB1))       then Cleanexit(ErrorTD_IO,10);
  444.     end;
  445.  
  446.     CMD__Test :        { --- BB testen - VORSICHT ! --- }
  447.     begin
  448.     If not (RWBB(dfx, CMD__Read, BB1))        then Cleanexit(ErrorTD_IO,10);
  449.  
  450.     { .... exec in a6, IOreq in a1, jsr bb^ , ... }
  451.  
  452.     end;
  453.  
  454.  
  455.     CMD__Help :        { --- How 2 use it --- }
  456.     begin
  457.     write(    "Usage : DxBoot cmd unit[0..3] <filename>\n",
  458.         "Available commands are:\n",
  459.         " chk   [unit#]        2 check if Std.-BB\n",
  460.         " read  [unit#] BBfile    2 save a BootBlock\n",
  461.         " write [unit#] BBFile    2 install a BB\n",
  462.         " inst  [unit#]        2 install a Std.-BB\n",
  463.         " cmp   [unit#] BBFile    2 cmp 2 a BB-file\n",
  464.         " type  [unit#]      4 a hexdump\n",
  465.         " test  [unit#]      2 execute a bootblock (Be aware!)\n",
  466.         " kill  [unit#]      2 get a NDOS-Disk\n",
  467.         " ?     [unit#]      4 help\n\n");
  468.     end;
  469.   END;
  470.  
  471.   Cleanexit(NIL,0);    { --- Bye !! --- }
  472.  
  473. END.                    { bye bye GTI ...}
  474.  
  475.  
  476.